home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Commodities / RunList3 / src / RunList3N.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-27  |  21.4 KB  |  810 lines
  1. /*
  2.  *  Source machine generated by GadToolsBox V2.0b
  3.  *  which is (c) Copyright 1991-1993 Jaba Development
  4.  *
  5.  *  GUI Designed by : -- Heinz Reinert --
  6.  */
  7.  
  8. #include <exec/types.h>
  9. #include <intuition/intuition.h>
  10. #include <intuition/classes.h>
  11. #include <intuition/classusr.h>
  12. #include <intuition/imageclass.h>
  13. #include <intuition/gadgetclass.h>
  14. #include <libraries/gadtools.h>
  15. #include <graphics/displayinfo.h>
  16. #include <graphics/gfxbase.h>
  17. #include <clib/exec_protos.h>
  18. #include <clib/intuition_protos.h>
  19. #include <clib/gadtools_protos.h>
  20. #include <clib/graphics_protos.h>
  21. #include <clib/utility_protos.h>
  22. #include <proto/intuition.h>
  23. #include <proto/graphics.h>
  24. #include <proto/exec.h>
  25. #include <proto/dos.h>
  26. #include <proto/gadtools.h>
  27. #include <exec/memory.h>
  28. #include <string.h>
  29.  
  30.                                     
  31.  
  32. #define GetString( g )      ((( struct StringInfo * )g->SpecialInfo )->Buffer  )
  33. #define GetNumber( g )      ((( struct StringInfo * )g->SpecialInfo )->LongInt )
  34.  
  35. #define GD_list                                0
  36. #define GD_new                                 1
  37. #define GD_del                                 2
  38. #define GD_descr                               3
  39. #define GD_command1                            4
  40. #define GD_command2                            5
  41. #define GD_command3                            6
  42. #define GD_save                                7
  43. #define GD_runa                                8
  44. #define GD_run3                                9
  45. #define GD_run2                                10
  46. #define GD_run1                                11
  47.  
  48. #define GDX_list                               0
  49. #define GDX_new                                1
  50. #define GDX_del                                2
  51. #define GDX_descr                              3
  52. #define GDX_command1                           4
  53. #define GDX_command2                           5
  54. #define GDX_command3                           6
  55. #define GDX_save                               7
  56. #define GDX_runa                               8
  57. #define GDX_run3                               9
  58. #define GDX_run2                               10
  59. #define GDX_run1                               11
  60.  
  61. #define Project0_CNT 12
  62. UBYTE *vers = "\0$VER: RunList 3";
  63.  
  64. extern struct IntuitionBase *IntuitionBase;
  65. extern struct Library       *GadToolsBase;
  66.  
  67. extern struct Screen        *Scr;
  68. extern UBYTE                 *PubScreenName;
  69. extern APTR                  VisualInfo;
  70. extern struct Window        *Project0Wnd;
  71. extern struct Gadget        *Project0GList;
  72. extern struct Gadget        *Project0Gadgets[12];
  73. extern UWORD                 Project0Left;
  74. extern UWORD                 Project0Top;
  75. extern UWORD                 Project0Width;
  76. extern UWORD                 Project0Height;
  77. extern UBYTE                *Project0Wdt;
  78. extern struct TextAttr       topaz8;
  79. extern UWORD                 Project0GTypes[];
  80. extern struct NewGadget      Project0NGad[];
  81. extern ULONG                 Project0GTags[];
  82.  
  83.  
  84. extern int SetupScreen( void );
  85. extern void CloseDownScreen( void );
  86. extern int OpenProject0Window( void );
  87. extern void CloseProject0Window( void );
  88.  
  89.  
  90. struct Screen         *Scr = NULL;
  91. UBYTE                 *PubScreenName = NULL;
  92. APTR                   VisualInfo = NULL;
  93. struct Window         *Project0Wnd = NULL;
  94. struct Gadget         *Project0GList = NULL;
  95. struct Gadget         *Project0Gadgets[12];
  96. UWORD                  Project0Left = 323;
  97. UWORD                  Project0Top = 10;
  98. UWORD                  Project0Width = 324;
  99. UWORD                  Project0Height = 0;
  100. UBYTE                 *Project0Wdt = (UBYTE *)"RunList 3";
  101.  
  102. struct TextAttr topaz8 = {
  103.                  ( STRPTR )"topaz.font", 8, 0x00, 0x01 };
  104.  
  105. UWORD Project0GTypes[] = {
  106.         LISTVIEW_KIND,
  107.         BUTTON_KIND,
  108.         BUTTON_KIND,
  109.         STRING_KIND,
  110.         STRING_KIND,
  111.         STRING_KIND,
  112.         STRING_KIND,
  113.         BUTTON_KIND,
  114.         BUTTON_KIND,
  115.         BUTTON_KIND,
  116.         BUTTON_KIND,
  117.         BUTTON_KIND
  118. };
  119.  
  120.  
  121. struct NewGadget Project0NGad[] = {
  122.         9, 4, 208, 96, NULL, NULL, GD_list, 0, NULL, NULL,
  123.         223, 4, 72, 12, (UBYTE *)"NEW", NULL, GD_new, PLACETEXT_IN, NULL, NULL,
  124.         223, 16, 72, 12, (UBYTE *)"DELETE", NULL, GD_del, PLACETEXT_IN, NULL, NULL,
  125.         9, 96, 208, 12, NULL, NULL, GD_descr, 0, NULL, NULL,
  126.         9, 111, 287, 12, NULL, NULL, GD_command1, 0, NULL, NULL,
  127.         9, 123, 287, 12, NULL, NULL, GD_command2, 0, NULL, NULL,
  128.         9, 135, 287, 12, NULL, NULL, GD_command3, 0, NULL, NULL,
  129.         223, 28, 72, 12, (UBYTE *)"SAVE", NULL, GD_save, PLACETEXT_IN, NULL, NULL,
  130.         223, 40, 72, 32, (UBYTE *)"RUN ALL", NULL, GD_runa, PLACETEXT_IN, NULL, NULL,
  131.         223, 96, 72, 12, (UBYTE *)"RUN 3", NULL, GD_run3, PLACETEXT_IN, NULL, NULL,
  132.         223, 84, 72, 12, (UBYTE *)"RUN 2", NULL, GD_run2, PLACETEXT_IN, NULL, NULL,
  133.         223, 72, 72, 12, (UBYTE *)"RUN 1", NULL, GD_run1, PLACETEXT_IN, NULL, NULL
  134. };
  135.  
  136.  
  137. ULONG Project0GTags[] = {
  138.         (TAG_DONE),
  139.         (TAG_DONE),
  140.         (TAG_DONE),
  141.         (GTST_MaxChars), 256, (TAG_DONE),
  142.         (GTST_MaxChars), 256, (TAG_DONE),
  143.         (GTST_MaxChars), 256, (TAG_DONE),
  144.         (GTST_MaxChars), 256, (TAG_DONE),
  145.         (TAG_DONE),
  146.         (TAG_DONE),
  147.         (TAG_DONE),
  148.         (TAG_DONE),
  149.         (TAG_DONE)
  150. };
  151.  
  152.  
  153.  
  154. int SetupScreen( void )
  155. {
  156.         if ( ! ( Scr = LockPubScreen( PubScreenName )))
  157.                 return( 1L );
  158.  
  159.         if ( ! ( VisualInfo = GetVisualInfo( Scr, TAG_DONE )))
  160.                 return( 2L );
  161.  
  162.         return( 0L );
  163. }
  164.  
  165. void CloseDownScreen( void )
  166. {
  167.         if ( VisualInfo ) {
  168.                 FreeVisualInfo( VisualInfo );
  169.                 VisualInfo = NULL;
  170.         }
  171.  
  172.         if ( Scr        ) {
  173.                 UnlockPubScreen( NULL, Scr );
  174.                 Scr = NULL;
  175.         }
  176. }
  177.  
  178. int OpenProject0Window( void )
  179. {
  180.         struct NewGadget        ng;
  181.         struct Gadget   *g;
  182.         UWORD           lc, tc;
  183.         UWORD           offx = Scr->WBorLeft, offy = Scr->WBorTop + Scr->RastPort.TxHeight + 1;
  184.  
  185.         if ( ! ( g = CreateContext( &Project0GList )))
  186.                 return( 1L );
  187.  
  188.         for( lc = 0, tc = 0; lc < Project0_CNT; lc++ ) {
  189.  
  190.                 CopyMem((char * )&Project0NGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  191.  
  192.                 ng.ng_VisualInfo = VisualInfo;
  193.                 ng.ng_TextAttr   = &topaz8;
  194.                 ng.ng_LeftEdge  += offx;
  195.                 ng.ng_TopEdge   += offy;
  196.  
  197.                 Project0Gadgets[ lc ] = g = CreateGadgetA((ULONG)Project0GTypes[ lc ], g, &ng, ( struct TagItem * )&Project0GTags[ tc ] );
  198.  
  199.                 while( Project0GTags[ tc ] ) tc += 2;
  200.                 tc++;
  201.  
  202.                 if ( NOT g )
  203.                         return( 2L );
  204.         }
  205.  
  206.         if ( ! ( Project0Wnd = OpenWindowTags( NULL,
  207.                                 WA_Left,        Project0Left,
  208.                                 WA_Top,         Project0Top,
  209.                                 WA_Width,       Project0Width,
  210.                                 WA_Height,      Project0Height + offy,
  211.                                 WA_IDCMP,       LISTVIEWIDCMP|
  212.                                                 BUTTONIDCMP|
  213.                                                 STRINGIDCMP|
  214.                                                 IDCMP_NEWSIZE|
  215.                                                 IDCMP_CLOSEWINDOW|
  216.                                                 IDCMP_CHANGEWINDOW|
  217.                                                 IDCMP_INTUITICKS |
  218.                                                 IDCMP_MOUSEBUTTONS|
  219.                                                 IDCMP_REFRESHWINDOW,
  220.                                 WA_Flags,       WFLG_SIZEGADGET|
  221.                                                 WFLG_DRAGBAR|
  222.                                                 WFLG_DEPTHGADGET|
  223.                                                 WFLG_CLOSEGADGET|
  224.                                                 WFLG_SMART_REFRESH,
  225.                                 WA_Gadgets,     Project0GList,
  226.                                 WA_Title,       Project0Wdt,
  227.                                 WA_ScreenTitle, "RunList 3   © Heinz Reinert 1995",
  228.                                 WA_PubScreen,   Scr,
  229.                                 WA_MinWidth,    324,
  230.                                 WA_MinHeight,   164,
  231.                                 WA_MaxWidth,    324,
  232.                                 WA_MaxHeight,   164,
  233.                                 TAG_DONE )))
  234.         return( 4L );
  235.  
  236.         GT_RefreshWindow( Project0Wnd, NULL );
  237.  
  238.         return( 0L );
  239. }
  240.  
  241. void CloseProject0Window( void )
  242. {
  243.         if ( Project0Wnd        ) {
  244.                 CloseWindow( Project0Wnd );
  245.                 Project0Wnd = NULL;
  246.         }
  247.  
  248.         if ( Project0GList      ) {
  249.                 FreeGadgets( Project0GList );
  250.                 Project0GList = NULL;
  251.         }
  252. }
  253.  
  254. /*
  255.  * Struktur für einen Datenbankeintrag
  256.  */
  257.  
  258. struct VDB {
  259.     char    Name[30];
  260.     char    list[256];
  261.     USHORT  new;
  262.     USHORT  del;
  263.     char    command1[81], command2[81], command3[81];
  264.     USHORT  save;
  265.     USHORT  runa;
  266.     USHORT  run3;
  267.     USHORT  run2;
  268.     USHORT  run1;
  269.                             
  270. };
  271.  
  272.  
  273.  
  274. struct VDBnode {
  275.         struct  Node n; /*** Für Liste    ***/
  276.         struct  VDB d;  /*** VDB-Struktur ***/
  277. };
  278.  
  279. /*
  280.  * Flags
  281.  */
  282.  
  283. #define VDBF_STEREO             1
  284.  
  285. /*
  286.  *
  287.  * In dieser Liste befinden sich die VDB-Nodes
  288.  *
  289.  */
  290.  
  291. struct List vdblist;
  292.  
  293. /*
  294.  * Der aktuelle Eintrag
  295.  */
  296.  
  297. struct VDBnode *currentprj;
  298.  
  299. /*
  300.  * Die von der Gadtoolsbox erzeugten Header
  301.  */
  302.  
  303.  
  304. /*
  305.  *
  306.  * Die Hilfsroutinen
  307.  *
  308.  */
  309.  
  310. /*
  311.  * Allgemeine Gadgets
  312.  */
  313.  
  314. /*
  315.  *      Gadtools-Gadget einschalten
  316.  */
  317. void gt_OnGadget( struct Gadget         *gad,
  318.                                   struct Window         *w )
  319. {
  320.         GT_SetGadgetAttrs( gad, w, NULL, GA_DISABLED, FALSE, TAG_DONE );
  321. }
  322. /*
  323.  *      ...und wieder aus...
  324.  */
  325. void gt_OffGadget( struct Gadget        *gad,
  326.                                    struct Window        *w )
  327. {
  328.         GT_SetGadgetAttrs( gad, w, NULL, GA_DISABLED, TRUE, TAG_DONE );
  329. }
  330.  
  331.  
  332. /*
  333.  *  String-Gadgets
  334.  */
  335. void gt_SetString( struct Gadget        *gad,
  336.                                    struct Window        *w,
  337.                                    char                         *string )
  338. {
  339.         GT_SetGadgetAttrs( gad, w, NULL, GTST_String, string, TAG_DONE );
  340. }
  341.  
  342. char * gt_GetString( struct Gadget      *gad )
  343. {
  344.         struct StringInfo *si = gad->SpecialInfo;
  345.  
  346.         if( si )
  347.                 return( ( char * ) si->Buffer );
  348.         else
  349.                 return( NULL );
  350. }
  351.  
  352. /*
  353.  * Listenverwaltung für Listview-Gadgets
  354.  */
  355.  
  356. /*
  357.  * Liste anhängen
  358.  * "list" kann ~0 (-1) sein, dann ist kein Listenzugriff möglich
  359.  */
  360.  
  361. void gt_AttachList(     struct Gadget   *lv,
  362.                                         struct Window   *w,
  363.                                         struct List     *list )
  364. {
  365.         GT_SetGadgetAttrs( lv, w, NULL, GTLV_Labels, list, TAG_DONE );
  366. }
  367.  
  368. /*
  369.  *  Aktuellen Eintrag setzen
  370.  */
  371. void gt_SetLV( struct Gadget    *gad,
  372.                            struct Window        *w,
  373.                            ULONG                        value)
  374. {
  375.         GT_SetGadgetAttrs( gad, w, NULL, GTLV_Selected, value, TAG_DONE );
  376. }
  377.  
  378. /*
  379.  * x-ten Eintrag aus einer Exec-Liste holen
  380.  */
  381. struct Node * gt_GetListEntry( struct List *l,
  382.                                                            int num )
  383. {
  384.         int count = 0;
  385.         struct Node *n = l->lh_Head;
  386.  
  387.         while( n->ln_Succ )
  388.         {
  389.                 if( num==count ) return( n );
  390.                 n = n->ln_Succ;
  391.                 count++;
  392.         }
  393.         return( NULL );
  394. }
  395. /*
  396.  * Nummer einer Node aus einer Liste feststellen
  397.  * -1 falls nicht in Liste
  398.  */
  399. int gt_GetListEntryNum( struct List *l,
  400.                                                 struct Node *n )
  401. {
  402.         int count = 0;
  403.         struct Node *r = l->lh_Head;
  404.  
  405.         while( r->ln_Succ )
  406.         {
  407.                 if( r==n ) return( count );
  408.                 r = r->ln_Succ;
  409.                 count++;
  410.         }
  411.         return( -1 );
  412. }
  413. /*
  414.  * Anzahl Einträge einer Liste zählen
  415.  */
  416. int gt_GetListNumEntries( struct List *l )
  417. {
  418.         int count = 0;
  419.         struct Node *n = l->lh_Head;
  420.  
  421.         while( n->ln_Succ )
  422.         {
  423.                 n = n->ln_Succ;
  424.                 count++;
  425.         }
  426.  
  427.         return( count );
  428. }
  429.  
  430. /************************************************************************/
  431.  
  432. /*
  433.  *
  434.  *  Liste laden
  435.  *
  436.  */
  437.  
  438. void loadprjlist( void )
  439. {
  440.         struct VDB new;
  441.         struct VDBnode *n;
  442.         BPTR f;
  443.  
  444.         /*** Liste initialisieren ***/
  445.         NewList( &vdblist );
  446.         currentprj = NULL;
  447.  
  448.         /*** Datei öffnen ***/
  449.         f = Open( "S:List.DAT", MODE_OLDFILE );
  450.         if( !f )
  451.                 return;
  452.  
  453.         /*** Einträge einlesen */
  454.         while( Read( f, &new, sizeof( new ) ) == sizeof( new ) )
  455.         {
  456.                 /*** newe Node ***/
  457.                 n = AllocVec( sizeof( *n ), 0 );
  458.                 if( !n )
  459.                         break;
  460.  
  461.                 /*** Struktur kopieren und an Liste anhängen ***/
  462.                 n->d = new;
  463.                 n->n.ln_Name = n->d.Name;
  464.                 n->n.ln_Pri      = - n->d.Name[0];
  465.                 Enqueue( &vdblist, (struct Node *) n );
  466.         }
  467.  
  468.         Close( f );
  469. }
  470.  
  471. /*
  472.  *      Liste speichern und freigeben 
  473.  */
  474.  
  475. void save_and_freeprjlist(void )
  476. {
  477.         struct VDBnode *n;
  478.         BPTR f;
  479.  
  480.         f = Open( "S:List.DAT", MODE_NEWFILE );
  481.  
  482.         while( ( n = (struct VDBnode * ) RemHead( &vdblist ) ) )
  483.         {
  484.                 /*** Node speichern... ***/
  485.                 if( f )
  486.                         Write( f, &n->d, sizeof( struct VDB ) );
  487.  
  488.                 /*** ...und freigeben ***/
  489.                 FreeVec( n );
  490.         }
  491.  
  492.         if( f )
  493.                 Close( f );
  494. }
  495.  
  496.  
  497. /************************************************************************/
  498.  
  499. /*
  500.  * Schaltet die Gadgets mit Ausnahme der Liste ein oder aus
  501.  * abhängig davon, ob gerade ein Listeneintrag aktiviert ist
  502.  * oder nicht
  503.  *
  504.  */
  505.  
  506. void checkonoff( void )
  507. {
  508.         int c;
  509.  
  510.         if( currentprj )
  511.         {
  512.                 for( c = GD_del; c < Project0_CNT; c++ )
  513.                         gt_OnGadget( Project0Gadgets[c], Project0Wnd );
  514.         }
  515.         else
  516.         {
  517.                 for( c = GD_del; c < Project0_CNT; c++ )
  518.                         gt_OffGadget( Project0Gadgets[c], Project0Wnd );
  519.         }
  520.  
  521. }
  522.  
  523. /*
  524.  *
  525.  *  Trägt die Werte aus der aktuellen Struktur in die
  526.  *  Gadgets ein
  527.  *
  528.  */
  529.  
  530. void setgadvals( void )
  531. {
  532.  
  533.         if( !currentprj )
  534.                 return;
  535.  
  536.         gt_SetString(   Project0Gadgets[ GD_descr ], Project0Wnd,
  537.                                                    currentprj->d.Name );
  538.         gt_SetString(   Project0Gadgets[ GD_command1 ], Project0Wnd,
  539.                                                    currentprj->d.command1 );
  540.         gt_SetString(   Project0Gadgets[ GD_command2 ], Project0Wnd,
  541.                                                    currentprj->d.command2 );
  542.         gt_SetString(   Project0Gadgets[ GD_command3 ], Project0Wnd,
  543.                                                    currentprj->d.command3 );
  544.  
  545.  
  546. }
  547.  
  548.  
  549. /*
  550.  *
  551.  *  Erzeugt einen neuen, leeren Eintrag 
  552.  *
  553.  */
  554.  
  555. void newvdb( void )
  556. {
  557.         struct VDBnode *new;
  558.  
  559.         new = AllocVec( sizeof( *new ), MEMF_CLEAR );
  560.  
  561.         if( !new )
  562.                 return;
  563.  
  564.         currentprj = new;
  565.  
  566.         new->n.ln_Name = new->d.Name;
  567.  
  568.         strcpy( new->d.Name, "new" );
  569.  
  570.         gt_AttachList( Project0Gadgets[GD_list], Project0Wnd, (struct List *) ~0 );
  571.  
  572.         new->n.ln_Pri    = - new->d.Name[0];
  573.         Enqueue( &vdblist, (struct Node *) new );
  574.  
  575.         gt_AttachList( Project0Gadgets[GD_list], Project0Wnd, &vdblist );
  576.  
  577.         gt_SetLV( Project0Gadgets[GD_list], Project0Wnd, gt_GetListEntryNum( &vdblist, new ) );
  578.         checkonoff();
  579.         setgadvals();
  580. }
  581.  
  582.  
  583.  
  584. /*
  585.  *      Gadget-Event bearbeiten
  586.  */
  587.  
  588. void dogadup( struct IntuiMessage *im )
  589. {
  590.         struct Gadget *g = im->IAddress;
  591.  
  592.         switch( g->GadgetID )
  593.         {
  594.  
  595. /*** Ein Listeneintrag ***/
  596. case GD_list:
  597.         currentprj = (struct VDBnode *) gt_GetListEntry( &vdblist, im->Code );
  598.         checkonoff();
  599.         setgadvals();
  600.         break;
  601.  
  602. /*** new ***/
  603. case GD_new:
  604.         newvdb();
  605.         break;
  606.  
  607. /*** Löschen ***/
  608. case GD_del:
  609.         if( currentprj )
  610.         {
  611.                 gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, (struct List *) ~0 );
  612.                 Remove( currentprj );
  613.                 FreeVec( currentprj );
  614.                 currentprj = FALSE;
  615.                 checkonoff();
  616.                 gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, &vdblist );
  617.                 gt_SetLV( Project0Gadgets[ GD_list ], Project0Wnd, ~0 );
  618.         }
  619.         break;
  620.  
  621. /*** KassettenName ***/
  622. case GD_descr:
  623.         if( currentprj )
  624.         {
  625.                 gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, (struct List *) ~0 );
  626.                 strcpy( currentprj->d.Name, gt_GetString( Project0Gadgets[ GD_descr ] ) );
  627.                 gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, &vdblist );
  628.         }
  629.         checkonoff();
  630.         break;
  631.  
  632.  
  633. case GD_command1:
  634.         if( currentprj )
  635.         {
  636.                 strcpy( currentprj->d.command1, gt_GetString( Project0Gadgets[ GD_command1 ] ) );
  637.         }
  638.         checkonoff();
  639.         break;
  640.  
  641. case GD_command2:
  642.         if( currentprj )
  643.         {
  644.                 strcpy( currentprj->d.command2, gt_GetString( Project0Gadgets[ GD_command2 ] ) );
  645.         }
  646.         checkonoff();
  647.         break;
  648.  
  649. case GD_command3:
  650.         if( currentprj )
  651.         {
  652.                strcpy( currentprj->d.command3, gt_GetString( Project0Gadgets[ GD_command3 ] ) );
  653.         }
  654.         checkonoff();
  655.         break;
  656.  
  657. case GD_runa:
  658.         {
  659.             Execute(currentprj->d.command1, NULL, Output());
  660.             Execute(currentprj->d.command2, NULL, Output());
  661.             Execute(currentprj->d.command3, NULL, Output());
  662.         }
  663.         checkonoff();
  664.         break;
  665.  
  666. case GD_run1:
  667.         {
  668.             Execute(currentprj->d.command1, NULL, Output());
  669.         }
  670.         checkonoff();
  671.         break;
  672.  
  673. case GD_run2:
  674.         {
  675.             Execute(currentprj->d.command2, NULL, Output());
  676.         }
  677.         checkonoff();
  678.         break;
  679.  
  680. case GD_run3:
  681.         {
  682.             Execute(currentprj->d.command3, NULL, Output());
  683.         }
  684.         checkonoff();
  685.         break;
  686.  
  687. case GD_save:
  688.         {
  689.             save_and_freeprjlist();
  690.             loadprjlist();
  691.         }
  692.         checkonoff();
  693.         break;
  694.         }
  695. }
  696.  
  697.  
  698. /*
  699.  * Programmstart
  700.  */
  701.  
  702. int main( void )
  703. {
  704.         struct IntuiMessage     *im,imsg;
  705.         BOOL   Done = FALSE;
  706.  
  707.         USHORT code;           /* Code. */
  708.         ULONG seconds, micros; /* Time. */
  709.  
  710.         /* Declare and initialize the time stamps: */
  711.         ULONG sec1 = 0;
  712.         ULONG mic1 = 0;
  713.         ULONG sec2 = 0;
  714.         ULONG mic2 = 0;
  715.  
  716.         /*** Bildschirm und Fenster öffnen ***/
  717.         SetupScreen();
  718.         OpenProject0Window();
  719.  
  720.         /*** Liste laden ***/
  721.         loadprjlist();
  722.  
  723.         /*** Liste anzeigen ***/
  724.         gt_AttachList( Project0Gadgets[GD_list], Project0Wnd, &vdblist );
  725.  
  726.         /*** Gadgets setzen ***/
  727.         checkonoff();
  728.  
  729.         /*** Hauptschleife ***/
  730.         while( !Done )
  731.         {
  732.  
  733.                 /*** Auf IntuiMessage warten ***/
  734.                 while( !( im=GT_GetIMsg( Project0Wnd->UserPort ) ) )
  735.                         WaitPort( Project0Wnd->UserPort );
  736.  
  737.                         code    = im->Code;
  738.                         seconds = im->Seconds;
  739.                         micros  = im->Micros;
  740.  
  741.                 /*** Kopieren ***/
  742.                 imsg = *im;
  743.                 GT_ReplyIMsg( im );             
  744.  
  745.                 switch( imsg.Class )
  746.                 {
  747.  
  748.                         /*** CLOSEWINDOW: Fenster schließen? ***/
  749.                         case IDCMP_CLOSEWINDOW:
  750.                                 Done = TRUE;
  751.                                 break;
  752.  
  753.                         /*** Gadgetup; ein Gadget wurde ausgewählt ***/
  754.                         /*** Wir bearbeiten Gadget-Events in einer ***/
  755.                         /*** eigenen Routine                                       ***/
  756.                         case GADGETUP:
  757.                                 dogadup( &imsg );
  758.                                 break;
  759.  
  760.  
  761.                         case IDCMP_MOUSEBUTTONS: /* The user pressed/released a mouse button. */
  762.                                 if( code == SELECTDOWN )
  763.                                 {
  764.                                    /* Left button pressed. */
  765.  
  766.                                    /* Save the old time: */
  767.                                     sec2 = sec1;
  768.                                     mic2 = mic1;
  769.  
  770.                                    /* Get the new time: */
  771.                                     sec1 = seconds;
  772.                                     mic1 = micros;
  773.  
  774.                                    /* Check if it was a double-click or not: */
  775.                                 if( DoubleClick( sec2, mic2, sec1, mic1 ) )
  776.                                 {
  777.                                     Execute("RUN >NIL: Shellwin ", NULL, Output());
  778.                                    /* Reset the values: */
  779.                                     sec1 = 0;
  780.                                     mic1 = 0;
  781.                                     }
  782.                                 }
  783.                                 break;    
  784.  
  785.  
  786.  
  787.                         /*** REFRESH: Grafikobjekte (Boxen) neu zeichnen ***/
  788.                         case IDCMP_REFRESHWINDOW:
  789.                                 GT_BeginRefresh( Project0Wnd );
  790.                                 GT_EndRefresh( Project0Wnd, TRUE );
  791.                                 break;
  792.  
  793.  
  794.                 }
  795.  
  796.         }
  797.  
  798.         /*** Fenster und Bildschirm wieder schließen ***/       
  799.         CloseProject0Window();
  800.         CloseDownScreen();
  801.  
  802.  
  803.         return(0);
  804. }
  805.     
  806.  
  807.  
  808.  
  809.  
  810.